Plotly is a cool R package for making interactive graphs. You can display them within R studio, embed them in Shiny apps or Markdown reports, or upload them to Plotly’s web server. Plotly can work with standard ggplot syntax, but can also be used to do cool 3D graphics that ggplot can’t easily do.

library(dplyr)

Attaching package: <U+393C><U+3E31>dplyr<U+393C><U+3E32>

The following objects are masked from <U+393C><U+3E31>package:stats<U+393C><U+3E32>:

    filter, lag

The following objects are masked from <U+393C><U+3E31>package:base<U+393C><U+3E32>:

    intersect, setdiff, setequal, union

Interactive ggplot graphs

First, we’ll create a basic scatter plot with ggplot.

height.sims <- read.csv("C:\\Users\\Jason Karl\\Documents\\GitHub\\REM504-DataScience\\Practice_Datasets\\height_compare_sims.csv", header = T, stringsAsFactors = F)
sc.plot <- ggplot(data=height.sims[height.sims$haf.sum>0,], aes(x=aim.sum,y=haf.sum))+geom_point()+
            geom_smooth(method="lm")
sc.plot

Now let’s pass it to plotly

ggplotly(sc.plot)

3D graphs with Plotly

Plotly has some cool features for doing 3D graphics. The structure is a bit different than ggplot, though. Let’s run an example with a test LiDAR dataset of a shrub.

That’s pretty cool. Let’s do some voxel analysis (think Minecraft) of this point cloud by summarizing how many lidar points fall within each voxel.

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